home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1996 May: Tool Chest / Developer CD Series May 1996 (Tool Chest) (Apple Computer) (1996).iso / Tool Chest / Development Tools & Languages / • Other Platforms / PCCTS 1.31 / dlg / dlg_p.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-03-10  |  16.7 KB  |  847 lines  |  [TEXT/MPS ]
  1. /*
  2.  * A n t l r  T r a n s l a t i o n  H e a d e r
  3.  *
  4.  * Terence Parr, Will Cohen, and Hank Dietz: 1989-1994
  5.  * Purdue University Electrical Engineering
  6.  * With AHPCRC, University of Minnesota
  7.  * ANTLR Version 1.31
  8.  */
  9. #include <stdio.h>
  10. #define ANTLR_VERSION    131
  11.  
  12. #include <ctype.h>
  13. #include "dlg.h"
  14. #ifdef MEMCHK
  15. #include "trax.h"
  16. #endif
  17. #define zzSET_SIZE 8
  18. #include "antlr.h"
  19. #include "tokens.h"
  20. #include "dlgdef.h"
  21. #include "mode.h"
  22. ANTLR_INFO
  23.  
  24. int    action_no = 0;       /* keep track of actions outputed */
  25. int    nfa_allocated = 0; /* keeps track of number of nfa nodes */
  26. nfa_node **nfa_array = NULL;/* root of binary tree that stores nfa array */
  27. nfa_node nfa_model_node;   /* model to initialize new nodes */
  28. set    used_chars;       /* used to label trans. arcs */
  29. set    used_classes;       /* classes or chars used to label trans. arcs */
  30. set    normal_chars;       /* mask to get rid elements that aren't used
  31. in set */
  32. int    flag_paren = FALSE;
  33. int    flag_brace = FALSE;
  34. int    mode_counter = 0;  /* keep track of number of %%names */
  35.  
  36.   
  37.  
  38. void
  39. #ifdef __STDC__
  40. grammar(void)
  41. #else
  42. grammar()
  43. #endif
  44. {
  45.     zzRULE;
  46.     zzBLOCK(zztasp1);
  47.     zzMake0;
  48.     {
  49.     p_head(); p_class_hdr(); func_action = FALSE;  
  50.     {
  51.         zzBLOCK(zztasp2);
  52.         zzMake0;
  53.         {
  54.         while ( (LA(1)==ACTION) ) {
  55.             zzmatch(ACTION); zzCONSUME;
  56.             zzLOOP(zztasp2);
  57.         }
  58.         zzEXIT(zztasp2);
  59.         }
  60.     }
  61.     if ( gen_cpp ) p_includes();  
  62.     start_states();
  63.     func_action = FALSE; p_tables(); p_tail();   
  64.     {
  65.         zzBLOCK(zztasp2);
  66.         zzMake0;
  67.         {
  68.         while ( (LA(1)==ACTION) ) {
  69.             zzmatch(ACTION); zzCONSUME;
  70.             zzLOOP(zztasp2);
  71.         }
  72.         zzEXIT(zztasp2);
  73.         }
  74.     }
  75.     zzmatch(1); zzCONSUME;
  76.     zzEXIT(zztasp1);
  77.     return;
  78. fail:
  79.     zzEXIT(zztasp1);
  80.     zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  81.     zzresynch(setwd1, 0x1);
  82.     }
  83. }
  84.  
  85. void
  86. #ifdef __STDC__
  87. start_states(void)
  88. #else
  89. start_states()
  90. #endif
  91. {
  92.     zzRULE;
  93.     zzBLOCK(zztasp1);
  94.     zzMake0;
  95.     {
  96.     {
  97.         zzBLOCK(zztasp2);
  98.         zzMake0;
  99.         {
  100.         if ( (LA(1)==PER_PER) ) {
  101.             zzmatch(PER_PER); zzCONSUME;
  102.             do_conversion();
  103.         }
  104.         else {
  105.             if ( (LA(1)==NAME_PER_PER) ) {
  106.                 zzmatch(NAME_PER_PER); zzCONSUME;
  107.                 do_conversion();
  108.                 {
  109.                     zzBLOCK(zztasp3);
  110.                     zzMake0;
  111.                     {
  112.                     while ( (LA(1)==NAME_PER_PER) ) {
  113.                         zzmatch(NAME_PER_PER); zzCONSUME;
  114.                         do_conversion();
  115.                         zzLOOP(zztasp3);
  116.                     }
  117.                     zzEXIT(zztasp3);
  118.                     }
  119.                 }
  120.             }
  121.             else {zzFAIL(1,zzerr1,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  122.         }
  123.         zzEXIT(zztasp2);
  124.         }
  125.     }
  126.     zzmatch(PER_PER); zzCONSUME;
  127.     zzEXIT(zztasp1);
  128.     return;
  129. fail:
  130.     zzEXIT(zztasp1);
  131.     zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  132.     zzresynch(setwd1, 0x2);
  133.     }
  134. }
  135.  
  136. void
  137. #ifdef __STDC__
  138. do_conversion(void)
  139. #else
  140. do_conversion()
  141. #endif
  142. {
  143.     zzRULE;
  144.     zzBLOCK(zztasp1);
  145.     zzMake0;
  146.     {
  147.     new_automaton_mode(); func_action = TRUE;  
  148.     rule_list();
  149.     
  150.     dfa_class_nop[mode_counter] =
  151.     relabel(zzaArg(zztasp1,1 ).l,comp_level);
  152.     if (comp_level)
  153.     p_shift_table(mode_counter);
  154.     dfa_basep[mode_counter] = dfa_allocated+1;
  155.     make_dfa_model_node(dfa_class_nop[mode_counter]);
  156.     nfa_to_dfa(zzaArg(zztasp1,1 ).l);
  157.     ++mode_counter;
  158.     func_action = FALSE;
  159. #ifdef HASH_STAT
  160.     fprint_hash_stats(stderr);
  161. #endif
  162.     zzEXIT(zztasp1);
  163.     return;
  164. fail:
  165.     zzEXIT(zztasp1);
  166.     zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  167.     zzresynch(setwd1, 0x4);
  168.     }
  169. }
  170.  
  171. void
  172. #ifdef __STDC__
  173. rule_list(void)
  174. #else
  175. rule_list()
  176. #endif
  177. {
  178.     zzRULE;
  179.     zzBLOCK(zztasp1);
  180.     zzMake0;
  181.     {
  182.     if ( (setwd1[LA(1)]&0x8) ) {
  183.         rule();
  184.         zzaRet.l=zzaArg(zztasp1,1 ).l; zzaRet.r=zzaArg(zztasp1,1 ).r;  
  185.         {
  186.             zzBLOCK(zztasp2);
  187.             zzMake0;
  188.             {
  189.             while ( (setwd1[LA(1)]&0x10) ) {
  190.                 rule();
  191.                 {nfa_node *t1;
  192.                     t1 = new_nfa_node();
  193.                     (t1)->trans[0]=zzaRet.l;
  194.                     (t1)->trans[1]=zzaArg(zztasp2,1 ).l;
  195.                     /* all accept nodes "dead ends" */
  196.                     zzaRet.l=t1; zzaRet.r=NULL;
  197.                 }
  198.                 zzLOOP(zztasp2);
  199.             }
  200.             zzEXIT(zztasp2);
  201.             }
  202.         }
  203.     }
  204.     else {
  205.         if ( (setwd1[LA(1)]&0x20) ) {
  206.             zzaRet.l = new_nfa_node(); zzaRet.r = NULL;
  207.             warning("no regular expressions", zzline);
  208.         }
  209.         else {zzFAIL(1,zzerr2,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  210.     }
  211.     zzEXIT(zztasp1);
  212.     return;
  213. fail:
  214.     zzEXIT(zztasp1);
  215.     zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  216.     zzresynch(setwd1, 0x40);
  217.     }
  218. }
  219.  
  220. void
  221. #ifdef __STDC__
  222. rule(void)
  223. #else
  224. rule()
  225. #endif
  226. {
  227.     zzRULE;
  228.     zzBLOCK(zztasp1);
  229.     zzMake0;
  230.     {
  231.     if ( (setwd1[LA(1)]&0x80) ) {
  232.         reg_expr();
  233.         zzmatch(ACTION);
  234.         zzaRet.l=zzaArg(zztasp1,1 ).l; zzaRet.r=zzaArg(zztasp1,1 ).r; (zzaArg(zztasp1,1 ).r)->accept=action_no;  
  235.  zzCONSUME;
  236.  
  237.     }
  238.     else {
  239.         if ( (LA(1)==ACTION) ) {
  240.             zzmatch(ACTION);
  241.             zzaRet.l = NULL; zzaRet.r = NULL;
  242.             error("no expression for action  ", zzline);
  243.  zzCONSUME;
  244.  
  245.         }
  246.         else {zzFAIL(1,zzerr3,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  247.     }
  248.     zzEXIT(zztasp1);
  249.     return;
  250. fail:
  251.     zzEXIT(zztasp1);
  252.     zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  253.     zzresynch(setwd2, 0x1);
  254.     }
  255. }
  256.  
  257. void
  258. #ifdef __STDC__
  259. reg_expr(void)
  260. #else
  261. reg_expr()
  262. #endif
  263. {
  264.     zzRULE;
  265.     zzBLOCK(zztasp1);
  266.     zzMake0;
  267.     {
  268.     and_expr();
  269.     zzaRet.l=zzaArg(zztasp1,1 ).l; zzaRet.r=zzaArg(zztasp1,1 ).r;  
  270.     {
  271.         zzBLOCK(zztasp2);
  272.         zzMake0;
  273.         {
  274.         while ( (LA(1)==OR) ) {
  275.             zzmatch(OR); zzCONSUME;
  276.             and_expr();
  277.             {nfa_node *t1, *t2;
  278.                 t1 = new_nfa_node(); t2 = new_nfa_node();
  279.                 (t1)->trans[0]=zzaRet.l;
  280.                 (t1)->trans[1]=zzaArg(zztasp2,2 ).l;
  281.                 (zzaRet.r)->trans[1]=t2;
  282.                 (zzaArg(zztasp2,2 ).r)->trans[1]=t2;
  283.                 zzaRet.l=t1; zzaRet.r=t2;
  284.             }
  285.             zzLOOP(zztasp2);
  286.         }
  287.         zzEXIT(zztasp2);
  288.         }
  289.     }
  290.     zzEXIT(zztasp1);
  291.     return;
  292. fail:
  293.     zzEXIT(zztasp1);
  294.     zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  295.     zzresynch(setwd2, 0x2);
  296.     }
  297. }
  298.  
  299. void
  300. #ifdef __STDC__
  301. and_expr(void)
  302. #else
  303. and_expr()
  304. #endif
  305. {
  306.     zzRULE;
  307.     zzBLOCK(zztasp1);
  308.     zzMake0;
  309.     {
  310.     repeat_expr();
  311.     zzaRet.l=zzaArg(zztasp1,1 ).l; zzaRet.r=zzaArg(zztasp1,1 ).r;  
  312.     {
  313.         zzBLOCK(zztasp2);
  314.         zzMake0;
  315.         {
  316.         while ( (setwd2[LA(1)]&0x4) ) {
  317.             repeat_expr();
  318.             (zzaRet.r)->trans[1]=zzaArg(zztasp2,1 ).l; zzaRet.r=zzaArg(zztasp2,1 ).r;  
  319.             zzLOOP(zztasp2);
  320.         }
  321.         zzEXIT(zztasp2);
  322.         }
  323.     }
  324.     zzEXIT(zztasp1);
  325.     return;
  326. fail:
  327.     zzEXIT(zztasp1);
  328.     zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  329.     zzresynch(setwd2, 0x8);
  330.     }
  331. }
  332.  
  333. void
  334. #ifdef __STDC__
  335. repeat_expr(void)
  336. #else
  337. repeat_expr()
  338. #endif
  339. {
  340.     zzRULE;
  341.     zzBLOCK(zztasp1);
  342.     zzMake0;
  343.     {
  344.     if ( (setwd2[LA(1)]&0x10) ) {
  345.         expr();
  346.         zzaRet.l=zzaArg(zztasp1,1 ).l; zzaRet.r=zzaArg(zztasp1,1 ).r;  
  347.         {
  348.             zzBLOCK(zztasp2);
  349.             zzMake0;
  350.             {
  351.             if ( (LA(1)==ZERO_MORE) ) {
  352.                 zzmatch(ZERO_MORE);
  353.                 {    nfa_node *t1,*t2;
  354.                     (zzaRet.r)->trans[0] = zzaRet.l;
  355.                     t1 = new_nfa_node(); t2 = new_nfa_node();
  356.                     t1->trans[0]=zzaRet.l;
  357.                     t1->trans[1]=t2;
  358.                     (zzaRet.r)->trans[1]=t2;
  359.                     zzaRet.l=t1;zzaRet.r=t2;
  360.                 }
  361.  zzCONSUME;
  362.  
  363.             }
  364.             else {
  365.                 if ( (LA(1)==ONE_MORE) ) {
  366.                     zzmatch(ONE_MORE);
  367.                     (zzaRet.r)->trans[0] = zzaRet.l;  
  368.  zzCONSUME;
  369.  
  370.                 }
  371.             }
  372.             zzEXIT(zztasp2);
  373.             }
  374.         }
  375.     }
  376.     else {
  377.         if ( (LA(1)==ZERO_MORE) ) {
  378.             zzmatch(ZERO_MORE);
  379.             error("no expression for *", zzline);  
  380.  zzCONSUME;
  381.  
  382.         }
  383.         else {
  384.             if ( (LA(1)==ONE_MORE) ) {
  385.                 zzmatch(ONE_MORE);
  386.                 error("no expression for +", zzline);  
  387.  zzCONSUME;
  388.  
  389.             }
  390.             else {zzFAIL(1,zzerr4,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  391.         }
  392.     }
  393.     zzEXIT(zztasp1);
  394.     return;
  395. fail:
  396.     zzEXIT(zztasp1);
  397.     zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  398.     zzresynch(setwd2, 0x20);
  399.     }
  400. }
  401.  
  402. void
  403. #ifdef __STDC__
  404. expr(void)
  405. #else
  406. expr()
  407. #endif
  408. {
  409.     zzRULE;
  410.     zzBLOCK(zztasp1);
  411.     zzMake0;
  412.     {
  413.     zzaRet.l = new_nfa_node(); zzaRet.r = new_nfa_node();   
  414.     if ( (LA(1)==L_BRACK) ) {
  415.         zzmatch(L_BRACK); zzCONSUME;
  416.         atom_list();
  417.         zzmatch(R_BRACK);
  418.         
  419.         (zzaRet.l)->trans[0] = zzaRet.r;
  420.         (zzaRet.l)->label = set_dup(zzaArg(zztasp1,2 ).label);
  421.         set_orin(&used_chars,(zzaRet.l)->label);
  422.  zzCONSUME;
  423.  
  424.     }
  425.     else {
  426.         if ( (LA(1)==NOT) ) {
  427.             zzmatch(NOT); zzCONSUME;
  428.             zzmatch(L_BRACK); zzCONSUME;
  429.             atom_list();
  430.             zzmatch(R_BRACK);
  431.             
  432.             (zzaRet.l)->trans[0] = zzaRet.r;
  433.             (zzaRet.l)->label = set_dif(normal_chars,zzaArg(zztasp1,3 ).label);
  434.             set_orin(&used_chars,(zzaRet.l)->label);
  435.  zzCONSUME;
  436.  
  437.         }
  438.         else {
  439.             if ( (LA(1)==L_PAR) ) {
  440.                 zzmatch(L_PAR); zzCONSUME;
  441.                 reg_expr();
  442.                 zzmatch(R_PAR);
  443.                 
  444.                 (zzaRet.l)->trans[0] = zzaArg(zztasp1,2 ).l;
  445.                 (zzaArg(zztasp1,2 ).r)->trans[1] = zzaRet.r;
  446.  zzCONSUME;
  447.  
  448.             }
  449.             else {
  450.                 if ( (LA(1)==L_BRACE) ) {
  451.                     zzmatch(L_BRACE); zzCONSUME;
  452.                     reg_expr();
  453.                     zzmatch(R_BRACE);
  454.                     
  455.                     (zzaRet.l)->trans[0] = zzaArg(zztasp1,2 ).l;
  456.                     (zzaRet.l)->trans[1] = zzaRet.r;
  457.                     (zzaArg(zztasp1,2 ).r)->trans[1] = zzaRet.r;
  458.  zzCONSUME;
  459.  
  460.                 }
  461.                 else {
  462.                     if ( (setwd2[LA(1)]&0x40) ) {
  463.                         atom();
  464.                         
  465.                         (zzaRet.l)->trans[0] = zzaRet.r;
  466.                         (zzaRet.l)->label = set_dup(zzaArg(zztasp1,1 ).label);
  467.                         set_orin(&used_chars,(zzaRet.l)->label);
  468.                     }
  469.                     else {zzFAIL(1,zzerr5,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  470.                 }
  471.             }
  472.         }
  473.     }
  474.     zzEXIT(zztasp1);
  475.     return;
  476. fail:
  477.     zzEXIT(zztasp1);
  478.     zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  479.     zzresynch(setwd2, 0x80);
  480.     }
  481. }
  482.  
  483. void
  484. #ifdef __STDC__
  485. atom_list(void)
  486. #else
  487. atom_list()
  488. #endif
  489. {
  490.     zzRULE;
  491.     zzBLOCK(zztasp1);
  492.     zzMake0;
  493.     {
  494.     set_free(zzaRet.label);   
  495.     {
  496.         zzBLOCK(zztasp2);
  497.         zzMake0;
  498.         {
  499.         while ( (setwd3[LA(1)]&0x1) ) {
  500.             near_atom();
  501.             set_orin(&(zzaRet.label),zzaArg(zztasp2,1 ).label);  
  502.             zzLOOP(zztasp2);
  503.         }
  504.         zzEXIT(zztasp2);
  505.         }
  506.     }
  507.     zzEXIT(zztasp1);
  508.     return;
  509. fail:
  510.     zzEXIT(zztasp1);
  511.     zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  512.     zzresynch(setwd3, 0x2);
  513.     }
  514. }
  515.  
  516. void
  517. #ifdef __STDC__
  518. near_atom(void)
  519. #else
  520. near_atom()
  521. #endif
  522. {
  523.     zzRULE;
  524.     zzBLOCK(zztasp1);
  525.     zzMake0;
  526.     {
  527.     register int i;
  528.     register int i_prime;
  529.     anychar();
  530.     zzaRet.letter=zzaArg(zztasp1,1 ).letter; zzaRet.label=set_of(zzaArg(zztasp1,1 ).letter);
  531.     i_prime = zzaArg(zztasp1,1 ).letter + MIN_CHAR;
  532.     if (case_insensitive && islower(i_prime))
  533.     set_orel(toupper(i_prime)-MIN_CHAR,
  534.     &(zzaRet.label));
  535.     if (case_insensitive && isupper(i_prime))
  536.     set_orel(tolower(i_prime)-MIN_CHAR,
  537.     &(zzaRet.label));
  538.     {
  539.         zzBLOCK(zztasp2);
  540.         zzMake0;
  541.         {
  542.         if ( (LA(1)==RANGE) ) {
  543.             zzmatch(RANGE); zzCONSUME;
  544.             anychar();
  545.             if (case_insensitive){
  546.                 i_prime = zzaRet.letter+MIN_CHAR;
  547.                 zzaRet.letter = (islower(i_prime) ?
  548.                 toupper(i_prime) : i_prime)-MIN_CHAR;
  549.                 i_prime = zzaArg(zztasp2,2 ).letter+MIN_CHAR;
  550.                 zzaArg(zztasp2,2 ).letter = (islower(i_prime) ?
  551.                 toupper(i_prime) : i_prime)-MIN_CHAR;
  552.             }
  553.             /* check to see if range okay */
  554.             if (zzaRet.letter > zzaArg(zztasp2,2 ).letter){
  555.                 error("invalid range  ", zzline);
  556.             }
  557.             for (i=zzaRet.letter; i<= (int)zzaArg(zztasp2,2 ).letter; ++i){
  558.                 set_orel(i,&(zzaRet.label));
  559.                 i_prime = i+MIN_CHAR;
  560.                 if (case_insensitive && islower(i_prime))
  561.                 set_orel(toupper(i_prime)-MIN_CHAR,
  562.                 &(zzaRet.label));
  563.                 if (case_insensitive && isupper(i_prime))
  564.                 set_orel(tolower(i_prime)-MIN_CHAR,
  565.                 &(zzaRet.label));
  566.             }
  567.         }
  568.         zzEXIT(zztasp2);
  569.         }
  570.     }
  571.     zzEXIT(zztasp1);
  572.     return;
  573. fail:
  574.     zzEXIT(zztasp1);
  575.     zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  576.     zzresynch(setwd3, 0x4);
  577.     }
  578. }
  579.  
  580. void
  581. #ifdef __STDC__
  582. atom(void)
  583. #else
  584. atom()
  585. #endif
  586. {
  587.     zzRULE;
  588.     zzBLOCK(zztasp1);
  589.     zzMake0;
  590.     {
  591.     register int i_prime;  
  592.     anychar();
  593.     zzaRet.label = set_of(zzaArg(zztasp1,1 ).letter);
  594.     i_prime = zzaArg(zztasp1,1 ).letter + MIN_CHAR;
  595.     if (case_insensitive && islower(i_prime))
  596.     set_orel(toupper(i_prime)-MIN_CHAR,
  597.     &(zzaRet.label));
  598.     if (case_insensitive && isupper(i_prime))
  599.     set_orel(tolower(i_prime)-MIN_CHAR,
  600.     &(zzaRet.label));
  601.     zzEXIT(zztasp1);
  602.     return;
  603. fail:
  604.     zzEXIT(zztasp1);
  605.     zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  606.     zzresynch(setwd3, 0x8);
  607.     }
  608. }
  609.  
  610. void
  611. #ifdef __STDC__
  612. anychar(void)
  613. #else
  614. anychar()
  615. #endif
  616. {
  617.     zzRULE;
  618.     zzBLOCK(zztasp1);
  619.     zzMake0;
  620.     {
  621.     if ( (LA(1)==REGCHAR) ) {
  622.         zzmatch(REGCHAR);
  623.         zzaRet.letter = zzaArg(zztasp1,1 ).letter - MIN_CHAR;  
  624.  zzCONSUME;
  625.  
  626.     }
  627.     else {
  628.         if ( (LA(1)==OCTAL_VALUE) ) {
  629.             zzmatch(OCTAL_VALUE);
  630.             zzaRet.letter = zzaArg(zztasp1,1 ).letter - MIN_CHAR;  
  631.  zzCONSUME;
  632.  
  633.         }
  634.         else {
  635.             if ( (LA(1)==HEX_VALUE) ) {
  636.                 zzmatch(HEX_VALUE);
  637.                 zzaRet.letter = zzaArg(zztasp1,1 ).letter - MIN_CHAR;  
  638.  zzCONSUME;
  639.  
  640.             }
  641.             else {
  642.                 if ( (LA(1)==DEC_VALUE) ) {
  643.                     zzmatch(DEC_VALUE);
  644.                     zzaRet.letter = zzaArg(zztasp1,1 ).letter - MIN_CHAR;  
  645.  zzCONSUME;
  646.  
  647.                 }
  648.                 else {
  649.                     if ( (LA(1)==TAB) ) {
  650.                         zzmatch(TAB);
  651.                         zzaRet.letter = zzaArg(zztasp1,1 ).letter - MIN_CHAR;  
  652.  zzCONSUME;
  653.  
  654.                     }
  655.                     else {
  656.                         if ( (LA(1)==NL) ) {
  657.                             zzmatch(NL);
  658.                             zzaRet.letter = zzaArg(zztasp1,1 ).letter - MIN_CHAR;  
  659.  zzCONSUME;
  660.  
  661.                         }
  662.                         else {
  663.                             if ( (LA(1)==CR) ) {
  664.                                 zzmatch(CR);
  665.                                 zzaRet.letter = zzaArg(zztasp1,1 ).letter - MIN_CHAR;  
  666.  zzCONSUME;
  667.  
  668.                             }
  669.                             else {
  670.                                 if ( (LA(1)==BS) ) {
  671.                                     zzmatch(BS);
  672.                                     zzaRet.letter = zzaArg(zztasp1,1 ).letter - MIN_CHAR;  
  673.  zzCONSUME;
  674.  
  675.                                 }
  676.                                 else {
  677.                                     if ( (LA(1)==LIT) ) {
  678.                                         zzmatch(LIT);
  679.                                         zzaRet.letter = zzaArg(zztasp1,1 ).letter - MIN_CHAR;  
  680.  zzCONSUME;
  681.  
  682.                                     }
  683.                                     else {
  684.                                         if ( (LA(1)==L_EOF) ) {
  685.                                             zzmatch(L_EOF);
  686.                                             zzaRet.letter = 0;  
  687.  zzCONSUME;
  688.  
  689.                                         }
  690.                                         else {zzFAIL(1,zzerr6,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  691.                                     }
  692.                                 }
  693.                             }
  694.                         }
  695.                     }
  696.                 }
  697.             }
  698.         }
  699.     }
  700.     zzEXIT(zztasp1);
  701.     return;
  702. fail:
  703.     zzEXIT(zztasp1);
  704.     /* empty action */  
  705.     zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  706.     zzresynch(setwd3, 0x10);
  707.     }
  708. }
  709.  
  710. /* adds a new nfa to the binary tree and returns a pointer to it */
  711. nfa_node *new_nfa_node()
  712. {
  713.     register nfa_node *t;
  714.     static int nfa_size=0;    /* elements nfa_array[] can hold */
  715.     
  716.     ++nfa_allocated;
  717.     if (nfa_size<=nfa_allocated){
  718.         /* need to redo array */
  719.         if (!nfa_array){
  720.             /* need some to do inital allocation */
  721.             nfa_size=nfa_allocated+NFA_MIN;
  722.             nfa_array=(nfa_node **) malloc(sizeof(nfa_node*)*
  723.             nfa_size);
  724.         }else{
  725.             /* need more space */
  726.             nfa_size=2*(nfa_allocated+1);
  727.             nfa_array=(nfa_node **) realloc(nfa_array, 
  728.             sizeof(nfa_node*)*nfa_size);
  729.         }
  730.     }
  731.     /* fill out entry in array */
  732.     t = (nfa_node*) malloc(sizeof(nfa_node));
  733.     nfa_array[nfa_allocated] = t;
  734.     *t = nfa_model_node;
  735.     t->node_no = nfa_allocated;
  736.     return t;
  737. }
  738.  
  739.  
  740. /* initialize the model node used to fill in newly made nfa_nodes */
  741. void
  742. make_nfa_model_node()
  743. {
  744.     nfa_model_node.node_no = -1; /* impossible value for real nfa node */
  745.     nfa_model_node.nfa_set = 0;
  746.     nfa_model_node.accept = 0;   /* error state default*/
  747.     nfa_model_node.trans[0] = NULL;
  748.     nfa_model_node.trans[1] = NULL;
  749.     nfa_model_node.label = empty;
  750. }
  751.  
  752. #ifdef DEBUG
  753.  
  754. /* print out the pointer value and the node_number */
  755. fprint_dfa_pair(f, p)
  756. FILE *f;
  757. nfa_node *p;
  758. {
  759.     if (p){
  760.         fprintf(f, "%x (%d)", p, p->node_no);
  761.     }else{
  762.         fprintf(f, "(nil)");
  763.     }
  764. }
  765.  
  766. /* print out interest information on a set */
  767. fprint_set(f,s)
  768. FILE *f;
  769. set s;
  770. {
  771.     unsigned int *x;
  772.     
  773.     fprintf(f, "n = %d,", s.n);
  774.     if (s.setword){
  775.         fprintf(f, "setword = %x,   ", s.setword);
  776.         /* print out all the elements in the set */
  777.         x = set_pdq(s);
  778.         while (*x!=nil){
  779.             fprintf(f, "%d ", *x);
  780.             ++x;
  781.         }
  782.     }else{
  783.         fprintf(f, "setword = (nil)");
  784.     }
  785. }
  786.  
  787. /* code to be able to dump out the nfas
  788. return 0 if okay dump
  789. return 1 if screwed up
  790. */
  791. int dump_nfas(first_node, last_node)
  792. int first_node;
  793. int last_node;
  794. {
  795.     register int i;
  796.     nfa_node *t;
  797.     
  798.     for (i=first_node; i<=last_node; ++i){
  799.         t = NFA(i);
  800.         if (!t) break;
  801.         fprintf(stderr, "nfa_node %d {\n", t->node_no);
  802.         fprintf(stderr, "\n\tnfa_set = %d\n", t->nfa_set);
  803.         fprintf(stderr, "\taccept\t=\t%d\n", t->accept);
  804.         fprintf(stderr, "\ttrans\t=\t(");
  805.         fprint_dfa_pair(stderr, t->trans[0]);
  806.         fprintf(stderr, ",");
  807.         fprint_dfa_pair(stderr, t->trans[1]);
  808.         fprintf(stderr, ")\n");
  809.         fprintf(stderr, "\tlabel\t=\t{ ");
  810.         fprint_set(stderr, t->label);
  811.         fprintf(stderr, "\t}\n");
  812.         fprintf(stderr, "}\n\n");
  813.     }
  814.     return 0;
  815. }
  816. #endif
  817.  
  818. /* DLG-specific syntax error message generator 
  819. * (define USER_ZZSYN when compiling so don't get 2 definitions)
  820. */
  821. void
  822. #ifdef __STDC__
  823. zzsyn(char *text, int tok, char *egroup, SetWordType *eset, int etok, int k, char *bad_text)
  824. #else
  825. zzsyn(text, tok, egroup, eset, etok, k, bad_text)
  826. char *text, *egroup, *bad_text;
  827. int tok;
  828. int etok;
  829. int k;
  830. SetWordType *eset;
  831. #endif
  832. {
  833. fprintf(stderr, ErrHdr, file_str[0]!=NULL?file_str[0]:"stdin", zzline);
  834. fprintf(stderr, " syntax error at \"%s\"", (tok==zzEOF_TOKEN)?"EOF":text);
  835. if ( !etok && !eset ) {fprintf(stderr, "\n"); return;}
  836. if ( k==1 ) fprintf(stderr, " missing");
  837. else
  838. {
  839. fprintf(stderr, "; \"%s\" not", bad_text);
  840. if ( zzset_deg(eset)>1 ) fprintf(stderr, " in");
  841. }
  842. if ( zzset_deg(eset)>0 ) zzedecode(eset);
  843. else fprintf(stderr, " %s", zztokens[etok]);
  844. if ( strlen(egroup) > 0 ) fprintf(stderr, " in %s", egroup);
  845. fprintf(stderr, "\n");
  846. }
  847.